package com.fiveGroup.controller;


import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.fiveGroup.pojo.*;
import com.fiveGroup.pojo.vo.DataVo;
import com.fiveGroup.pojo.vo.ProductVo;
import com.fiveGroup.service.*;
import com.fiveGroup.util.UserContextHolder;
import jakarta.validation.Valid;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.util.StringUtils;
import org.springframework.web.bind.annotation.*;

import java.time.LocalDate;
import java.util.ArrayList;
import java.util.List;

// 商品控制层
@RestController
@RequestMapping("/api/product")
@Slf4j
// 构造注入
@RequiredArgsConstructor
public class ProductController {


    private final ProductService productService;
    private final ProductImageService productImageService;
    private final ProductReviewService productReviewService;
    private final UserFavoriteProductService userFavoriteProductService;
    private final UserService userService;
    private final CategoryService categoryService;


    // 查询所有商品
    @GetMapping("/getGoodList")
    public DataVo getGoodList(@RequestParam(defaultValue = "1") int currentPage,
                              @RequestParam(defaultValue = "5") int pageSize,
                              @RequestParam(required = false) String productName,
                              @RequestParam(required = false) String categoryName,
                              @RequestParam(required = false) String createdAt) {

        UserContextHolder.getUserId();
        IPage<ProductVo> productIPage = new Page<>(currentPage, pageSize);
        QueryWrapper<Product> productQueryWrapper = new QueryWrapper<>();

        // 只允许审核通过的商品被展示
        productQueryWrapper.eq("p.status", 1);

        // 原有条件
        productQueryWrapper.likeRight(StringUtils.hasText(productName), "p.name", productName);
        productQueryWrapper.likeRight(StringUtils.hasText(categoryName), "c.name", categoryName);
        productQueryWrapper.like(StringUtils.hasText(createdAt), "p.created_at", createdAt);


        List<ProductVo> list = productService.listAll(productIPage, productQueryWrapper);

        // 补充：为每个商品查询图片列表
        for (ProductVo productVo : list) {
            QueryWrapper<ProductImage> imageWrapper = new QueryWrapper<>();
            imageWrapper.eq("product_id", productVo.getId()).orderByAsc("sort");
            List<ProductImage> images = productImageService.list(imageWrapper);
            productVo.setImages(images);
        }

        productIPage.setRecords(list);

        return DataVo.success(productIPage);
    }

    @PostMapping("/addGood")
    public DataVo addGood(@RequestBody @Valid ProductVo productVo) {
        // 获取当前上下文用户id
        Long userId = null;
        try {
            userId = UserContextHolder.getUserId();
        } catch (Exception e) {
            return DataVo.fail("用户未登录");
        }
        // 验证用户是否存在
        User seller = userService.getById(userId);
        if (seller == null) {
            return DataVo.fail("用户不存在");
        }

        if (productVo.getImages().isEmpty()) {
            return DataVo.fail("图片不能为空");
        }

        // 手动创建商品实体
        Product product = new Product();
        // 商品名称
        product.setName(productVo.getName());
        // 商品描述
        product.setDescription(productVo.getDescription());
        // 商品价格
        product.setPrice(productVo.getPrice());
        // 商品状态都是待审核
        product.setStatus(2);
        // 商品状态都是待审核
        product.setAuditRemark(null);
        // 审核状态都是待审核
        product.setAuditStatus(0);
        // 商品分类
        product.setCategoryId(productVo.getCategoryId());
        // 商品卖家id
        product.setSellerId(userId);
        // 商品创建时间
        product.setCreatedAt(LocalDate.now());
        // 商品更新时间
        product.setUpdatedAt(LocalDate.now());
        //商品浏览次数
        product.setViewCount(0);

        // 保存商品基本信息
        boolean productSaved = productService.save(product);
        if (!productSaved) {
            return DataVo.fail("商品保存失败");
        }

        // 保存商品图片
        if (productVo.getImages() != null && !productVo.getImages().isEmpty()) {
            List<ProductImage> imageList = new ArrayList<>();
            int sort = 1;

            // 循环批量添加图片
            for (ProductImage image : productVo.getImages()) {
                ProductImage productImage = new ProductImage();
                productImage.setProductId(product.getId());
                productImage.setImageUrl(image.getImageUrl());
                productImage.setSort(sort++);
                imageList.add(productImage);
            }

            // 批量保存图片
            boolean imagesSaved = productImageService.saveBatch(imageList);
            if (!imagesSaved) {
                // 如果图片保存失败，删除已保存的商品
                productService.removeById(product.getId());
                return DataVo.fail("商品图片保存失败");
            }
        }

        // 返回成功结果
        return DataVo.success("商品添加成功");
    }


    @DeleteMapping("/deleteGood/{id}")
    public DataVo deleteGood(@PathVariable Long id) {

        // 获取当前上下文用户id
        Long userId = UserContextHolder.getUserId();
        if (userId == null) {
            return DataVo.fail("用户未登录");
        }


        // 验证用户是否存在
        User seller = userService.getById(userId);
        if (seller == null) {
            return DataVo.fail("用户不存在");
        }
        Product product = productService.getById(id);
        if (product == null) {
            return DataVo.fail("商品不存在");
        }

        // 验证当前用户是否有权限删除
        if (!product.getSellerId().equals(userId)) {
            return DataVo.fail("无权删除此商品");
        }

        // 删除图片，通过id删除图片表中的图片
        QueryWrapper<ProductImage> imageWrapper = new QueryWrapper<>();
        imageWrapper.eq("product_id", id);
        productImageService.remove(imageWrapper);

        // 删除有关这张表的评论
        QueryWrapper<ProductReview> reviewWrapper = new QueryWrapper<>();
        reviewWrapper.eq("product_id", id);
        productReviewService.remove(reviewWrapper);

        // 删除有关这张表的收藏
        QueryWrapper<UserFavoriteProduct> favoriteProductQueryWrapper = new QueryWrapper<>();
        favoriteProductQueryWrapper.eq("product_id", id);
        userFavoriteProductService.remove(favoriteProductQueryWrapper);

        // 删除商品
        boolean deleted = productService.removeById(id);
        if (!deleted) {
            return DataVo.fail("商品删除失败");
        }

        return DataVo.success("商品删除成功");
    }

    @PutMapping("/updateGood")
    public DataVo updateGood(@RequestBody ProductVo productVo) {

        // 判断商品id是否存在
        if (productVo == null || productVo.getId() == null) {
            return DataVo.fail("商品ID不能为空");
        }

        // 获取当前上下文用户id
        Long userId = UserContextHolder.getUserId();
        if (userId == null) {
            return DataVo.fail("用户未登录");
        }

        // 验证用户是否存在
        User seller = userService.getById(userId);
        if (seller == null) {
            return DataVo.fail("用户不存在");
        }

        // 验证当前用户是否有权限删除
        if (!productVo.getSellerId().equals(userId)) {
            return DataVo.fail("无权修改此商品");
        }

        // 更新商品信息, 不可以修改商品的审核状态
        Product product = new Product();
        product.setId(productVo.getId());
        product.setName(productVo.getName());
        product.setDescription(productVo.getDescription());
        product.setPrice(productVo.getPrice());
        product.setAuditRemark(productVo.getAuditRemark());
        // 每次修改完商品后，审核状态变为未审核
        product.setAuditStatus(0);
        // 修改完商品后，审核状态改为审核中
        product.setStatus(2);
        product.setCategoryId(productVo.getCategoryId());
        product.setStatus(productVo.getStatus());
        product.setUpdatedAt(LocalDate.now());

        boolean updated = productService.updateById(product);
        if (!updated) {
            return DataVo.fail("商品更新失败");
        }

        //  更新商品图片
        if (productVo.getImages() != null) {

            // 删除旧的图片
            QueryWrapper<ProductImage> deleteWrapper = new QueryWrapper<>();
            deleteWrapper.eq("product_id", productVo.getId());
            productImageService.remove(deleteWrapper);

            // 添加新的图片
            if (!productVo.getImages().isEmpty()) {
                List<ProductImage> imageList = new ArrayList<>();
                int sort = 1;

                // 遍历添加新图片
                for (ProductImage image : productVo.getImages()) {
                    ProductImage productImage = new ProductImage();
                    productImage.setProductId(product.getId());
                    productImage.setImageUrl(image.getImageUrl()); // 此处需确保前端传递了有效的图片地址
                    productImage.setSort(sort++);
                    imageList.add(productImage);
                }

                productImageService.saveBatch(imageList);
            }
        }

        // 成功后，返回商品id
        return DataVo.success("商品更新成功, ID为:" + product.getId());

    }

    // 增加商品浏览量
    @PostMapping("/increaseViewCount/{id}")
    public DataVo increaseViewCount(@PathVariable Long id) {
        Product product = productService.getById(id);
        if (product == null) {
            return DataVo.fail("商品不存在");
        }
        // 浏览量+1（实际项目中建议用MyBatis的update语句直接更新，避免并发问题）
        product.setViewCount(product.getViewCount() == 0 ? 1 : product.getViewCount() + 1);
        // 返回商品id
        productService.updateById(product);

        return DataVo.success("浏览量更新成功");
    }


    /**
     * 查询当前登录用户发布的商品列表
     */
    @GetMapping("/myGoods")
    public DataVo getMyGoodsList(@RequestParam(defaultValue = "1") int currentPage,
                                 @RequestParam(defaultValue = "10") int pageSize,
                                 @RequestParam(required = false) Integer status,
                                 @RequestParam(required = false) String productName) { // 可选：增加商品名称搜索
        // 1. 获取当前登录用户ID（校验登录状态）
        Long userId = null;
        try {
            userId = UserContextHolder.getUserId();
        } catch (Exception e) {
            return DataVo.fail("用户未登录");
        }

        // 2. 初始化分页对象（泛型指定为 ProductVo，解决类型不匹配问题）
        IPage<ProductVo> productVoIPage = new Page<>(currentPage, pageSize);

        // 3. 构建查询条件（关联 product 表，筛选当前用户的商品）
        QueryWrapper<Product> queryWrapper = new QueryWrapper<>();
        // 核心：只查询当前登录用户发布的商品（seller_id = 当前用户ID）
        queryWrapper.eq("p.seller_id", userId);
        // 可选：商品状态筛选（如上架、下架、审核中）
        if (status != null) {
            queryWrapper.eq("p.status", status);
        }
        // 可选：商品名称模糊搜索
        if (StringUtils.hasText(productName)) {
            queryWrapper.likeRight("p.name", productName);
        }

        // 4. 调用 Mapper 层 listAll 方法（直接关联查询图片、分类，避免 N+1 查询）
        // 注：需确保 ProductService 和 ProductMapper 中已定义 listAll 方法，参数为 IPage<ProductVo> 和 QueryWrapper<Product>
        List<ProductVo> productVoList = productService.listAll(productVoIPage, queryWrapper);
        productVoIPage.setRecords(productVoList);

        // 5. 返回分页结果（此时类型完全匹配，无爆红）
        return DataVo.success(productVoIPage);
    }

    // 新增根据ID获取商品详情接口
    @GetMapping("/getGoodForEdit/{id}")
    public DataVo getGoodForEdit(@PathVariable Long id) {
        Long userId = UserContextHolder.getUserId();
        ProductVo productVo = productService.getGoodById(id);

        if (userId == null) {
            return DataVo.fail("请先登录");
        }

        if (productVo == null) {
            return DataVo.fail("商品不存在");
        }


        // 查询商品图片
        QueryWrapper<ProductImage> imageWrapper = new QueryWrapper<>();
        imageWrapper.eq("product_id", id).orderByAsc("sort");
        List<ProductImage> images = productImageService.list(imageWrapper);
        productVo.setImages(images);

        return DataVo.success(productVo);
    }
}